/*
** 2000-05-29
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** Driver template for the LEMON parser generator.
**
** The "lemon" program processes an LALR(1) input grammar file, then uses
** this template to construct a parser.  The "lemon" program inserts text
** at each "%%" line.  Also, any "P-a-r-s-e" identifer prefix (without the
** interstitial "-" characters) contained in this template is changed into
** the value of the %name directive from the grammar.  Otherwise, the content
** of this template is copied straight through into the generate parser
** source file.
**
** The following is the concatenation of all %include directives from the
** input grammar file:
*/
#include <stdio.h>
/************ Begin %include sections from the grammar ************************/

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

#include "libMultiMarkdown.h"
#include "mmd.h"
#include "parser.h"
#include "token.h"
/**************** End of %include directives **********************************/
/* These constants specify the various numeric values for terminal symbols
** in a format understandable to "makeheaders".  This section is blank unless
** "lemon" is run with the "-m" command-line option.
***************** Begin makeheaders token definitions *************************/
/**************** End makeheaders token definitions ***************************/

/* The next sections is a series of control #defines.
** various aspects of the generated parser.
**    YYCODETYPE         is the data type used to store the integer codes
**                       that represent terminal and non-terminal symbols.
**                       "unsigned char" is used if there are fewer than
**                       256 symbols.  Larger types otherwise.
**    YYNOCODE           is a number of type YYCODETYPE that is not used for
**                       any terminal or nonterminal symbol.
**    YYFALLBACK         If defined, this indicates that one or more tokens
**                       (also known as: "terminal symbols") have fall-back
**                       values which should be used if the original symbol
**                       would not parse.  This permits keywords to sometimes
**                       be used as identifiers, for example.
**    YYACTIONTYPE       is the data type used for "action codes" - numbers
**                       that indicate what to do in response to the next
**                       token.
**    OPMLTOKENTYPE     is the data type used for minor type for terminal
**                       symbols.  Background: A "minor type" is a semantic
**                       value associated with a terminal or non-terminal
**                       symbols.  For example, for an "ID" terminal symbol,
**                       the minor type might be the name of the identifier.
**                       Each non-terminal can have a different minor type.
**                       Terminal symbols all have the same minor type, though.
**                       This macros defines the minor type for terminal
**                       symbols.
**    YYMINORTYPE        is the data type used for all minor types.
**                       This is typically a union of many types, one of
**                       which is OPMLTOKENTYPE.  The entry in the union
**                       for terminal symbols is called "yy0".
**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
**                       zero the stack is dynamically sized using realloc()
**    OPMLARG_SDECL     A static variable declaration for the %extra_argument
**    OPMLARG_PDECL     A parameter declaration for the %extra_argument
**    OPMLARG_STORE     Code to store %extra_argument into yypParser
**    OPMLARG_FETCH     Code to extract %extra_argument from yypParser
**    YYERRORSYMBOL      is the code number of the error symbol.  If not
**                       defined, then do no error processing.
**    YYNSTATE           the combined number of states.
**    YYNRULE            the number of rules in the grammar
**    YY_MAX_SHIFT       Maximum value for shift actions
**    YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
**    YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
**    YY_MIN_REDUCE      Maximum value for reduce actions
**    YY_ERROR_ACTION    The yy_action[] code for syntax error
**    YY_ACCEPT_ACTION   The yy_action[] code for accept
**    YY_NO_ACTION       The yy_action[] code for no-op
*/
#ifndef INTERFACE
	#define INTERFACE 1
#endif
/************* Begin control #defines *****************************************/
#define YYCODETYPE unsigned char
#define YYNOCODE 26
#define YYACTIONTYPE unsigned char
#define OPMLTOKENTYPE  token *
typedef union {
	int yyinit;
	OPMLTOKENTYPE yy0;
} YYMINORTYPE;
#ifndef YYSTACKDEPTH
	#define YYSTACKDEPTH 100
#endif
#define OPMLARG_SDECL  mmd_engine * engine ;
#define OPMLARG_PDECL , mmd_engine * engine
#define OPMLARG_FETCH  mmd_engine * engine  = yypParser->engine
#define OPMLARG_STORE yypParser->engine  = engine
#define YYNSTATE             19
#define YYNRULE              19
#define YY_MAX_SHIFT         18
#define YY_MIN_SHIFTREDUCE   35
#define YY_MAX_SHIFTREDUCE   53
#define YY_MIN_REDUCE        54
#define YY_MAX_REDUCE        72
#define YY_ERROR_ACTION      73
#define YY_ACCEPT_ACTION     74
#define YY_NO_ACTION         75
/************* End control #defines *******************************************/

/* Define the yytestcase() macro to be a no-op if is not already defined
** otherwise.
**
** Applications can choose to define yytestcase() in the %include section
** to a macro that can assist in verifying code coverage.  For production
** code the yytestcase() macro should be turned off.  But it is useful
** for testing.
*/
#ifndef yytestcase
	#define yytestcase(X)
#endif


/* Next are the tables used to determine what action to take based on the
** current state and lookahead token.  These tables are used to implement
** functions that take a state number and lookahead value and return an
** action integer.
**
** Suppose the action integer is N.  Then the action is determined as
** follows
**
**   0 <= N <= YY_MAX_SHIFT             Shift N.  That is, push the lookahead
**                                      token onto the stack and goto state N.
**
**   N between YY_MIN_SHIFTREDUCE       Shift to an arbitrary state then
**     and YY_MAX_SHIFTREDUCE           reduce by rule N-YY_MIN_SHIFTREDUCE.
**
**   N between YY_MIN_REDUCE            Reduce by rule N-YY_MIN_REDUCE
**     and YY_MAX_REDUCE
**
**   N == YY_ERROR_ACTION               A syntax error has occurred.
**
**   N == YY_ACCEPT_ACTION              The parser accepts its input.
**
**   N == YY_NO_ACTION                  No such action.  Denotes unused
**                                      slots in the yy_action[] table.
**
** The action table is constructed as a single large table named yy_action[].
** Given state S and lookahead X, the action is computed as either:
**
**    (A)   N = yy_action[ yy_shift_ofst[S] + X ]
**    (B)   N = yy_default[S]
**
** The (A) formula is preferred.  The B formula is used instead if:
**    (1)  The yy_shift_ofst[S]+X value is out of range, or
**    (2)  yy_lookahead[yy_shift_ofst[S]+X] is not equal to X, or
**    (3)  yy_shift_ofst[S] equal YY_SHIFT_USE_DFLT.
** (Implementation note: YY_SHIFT_USE_DFLT is chosen so that
** YY_SHIFT_USE_DFLT+X will be out of range for all possible lookaheads X.
** Hence only tests (1) and (2) need to be evaluated.)
**
** The formulas above are for computing the action when the lookahead is
** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
** a reduce action) then the yy_reduce_ofst[] array is used in place of
** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
** YY_SHIFT_USE_DFLT.
**
** The following are the tables generated in this section:
**
**  yy_action[]        A single table containing all actions.
**  yy_lookahead[]     A table containing the lookahead for each entry in
**                     yy_action.  Used to detect hash collisions.
**  yy_shift_ofst[]    For each state, the offset into yy_action for
**                     shifting terminals.
**  yy_reduce_ofst[]   For each state, the offset into yy_action for
**                     shifting non-terminals after a reduce.
**  yy_default[]       Default action for each state.
**
*********** Begin parsing tables **********************************************/
#define YY_ACTTAB_COUNT (60)
static const YYACTIONTYPE yy_action[] = {
	/*     0 */     1,   49,   15,    3,   53,   46,    1,   47,   15,    3,
	/*    10 */    53,    1,   52,   15,    3,   53,    1,   51,   15,    3,
	/*    20 */    53,   45,    1,   13,   15,    3,   53,    1,   16,   15,
	/*    30 */     3,   53,   74,   18,   11,   10,    2,    4,    9,   14,
	/*    40 */     6,    6,    7,    7,    5,    5,    8,    4,   43,   12,
	/*    50 */     2,   17,   39,   44,   42,   41,   40,   38,   50,   54,
};
static const YYCODETYPE yy_lookahead[] = {
	/*     0 */    11,   12,   13,   14,   15,   10,   11,   24,   13,   14,
	/*    10 */    15,   11,   12,   13,   14,   15,   11,   12,   13,   14,
	/*    20 */    15,   10,   11,   22,   13,   14,   15,   11,   21,   13,
	/*    30 */    14,   15,   17,   18,   19,    1,    9,    3,   20,   21,
	/*    40 */    23,   24,   23,   24,   23,   24,    5,    3,    6,    7,
	/*    50 */     9,   19,    2,    8,    6,    4,    4,    2,   12,    0,
};
#define YY_SHIFT_USE_DFLT (60)
#define YY_SHIFT_COUNT    (18)
#define YY_SHIFT_MIN      (-11)
#define YY_SHIFT_MAX      (59)
static const signed char yy_shift_ofst[] = {
	/*     0 */    34,  -11,   -5,   16,   41,    0,    5,   11,   42,   27,
	/*    10 */    44,   50,   45,   48,   51,   46,   52,   55,   59,
};
#define YY_REDUCE_USE_DFLT (-18)
#define YY_REDUCE_COUNT (10)
#define YY_REDUCE_MIN   (-17)
#define YY_REDUCE_MAX   (32)
static const signed char yy_reduce_ofst[] = {
	/*     0 */    15,   17,   19,   21,   18,  -17,  -17,  -17,    1,    7,
	/*    10 */    32,
};
static const YYACTIONTYPE yy_default[] = {
	/*     0 */    73,   73,   73,   73,   73,   73,   73,   73,   73,   73,
	/*    10 */    73,   56,   73,   73,   73,   73,   73,   55,   73,
};
/********** End of lemon-generated parsing tables *****************************/

/* The next table maps tokens (terminal symbols) into fallback tokens.
** If a construct like the following:
**
**      %fallback ID X Y Z.
**
** appears in the grammar, then ID becomes a fallback token for X, Y,
** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
** but it does not parse, the type of the token is changed to ID and
** the parse is retried before an error is thrown.
**
** This feature can be used, for example, to cause some keywords in a language
** to revert to identifiers if they keyword does not apply in the context where
** it appears.
*/
#ifdef YYFALLBACK
static const YYCODETYPE yyFallback[] = {
};
#endif /* YYFALLBACK */

/* The following structure represents a single element of the
** parser's stack.  Information stored includes:
**
**   +  The state number for the parser at this level of the stack.
**
**   +  The value of the token stored at this level of the stack.
**      (In other words, the "major" token.)
**
**   +  The semantic value stored at this level of the stack.  This is
**      the information used by the action routines in the grammar.
**      It is sometimes called the "minor" token.
**
** After the "shift" half of a SHIFTREDUCE action, the stateno field
** actually contains the reduce action for the second half of the
** SHIFTREDUCE.
*/
struct yyStackEntry {
	YYACTIONTYPE stateno;  /* The state-number, or reduce action in SHIFTREDUCE */
	YYCODETYPE major;      /* The major token value.  This is the code
                         ** number for the token at this stack level */
	YYMINORTYPE minor;     /* The user-supplied minor token value.  This
                         ** is the value of the token  */
};
typedef struct yyStackEntry yyStackEntry;

/* The state of the parser is completely contained in an instance of
** the following structure */
struct yyParser {
	yyStackEntry * yytos;         /* Pointer to top element of the stack */
#ifdef YYTRACKMAXSTACKDEPTH
	int yyhwm;                    /* High-water mark of the stack */
#endif
#ifndef YYNOERRORRECOVERY
	int yyerrcnt;                 /* Shifts left before out of the error */
#endif
	OPMLARG_SDECL                /* A place to hold %extra_argument */
#if YYSTACKDEPTH<=0
	int yystksz;                  /* Current side of the stack */
	yyStackEntry * yystack;       /* The parser's stack */
	yyStackEntry yystk0;          /* First stack entry */
#else
	yyStackEntry yystack[YYSTACKDEPTH];  /* The parser's stack */
#endif
};
typedef struct yyParser yyParser;

#ifndef NDEBUG
	#include <stdio.h>
	static FILE * yyTraceFILE = 0;
	static char * yyTracePrompt = 0;
#endif /* NDEBUG */

#ifndef NDEBUG
/*
** Turn parser tracing on by giving a stream to which to write the trace
** and a prompt to preface each trace message.  Tracing is turned off
** by making either argument NULL
**
** Inputs:
** <ul>
** <li> A FILE* to which trace output should be written.
**      If NULL, then tracing is turned off.
** <li> A prefix string written at the beginning of every
**      line of trace output.  If NULL, then tracing is
**      turned off.
** </ul>
**
** Outputs:
** None.
*/
void OPMLTrace(FILE * TraceFILE, char * zTracePrompt) {
	yyTraceFILE = TraceFILE;
	yyTracePrompt = zTracePrompt;

	if ( yyTraceFILE == 0 ) {
		yyTracePrompt = 0;
	} else if ( yyTracePrompt == 0 ) {
		yyTraceFILE = 0;
	}
}
#endif /* NDEBUG */

#ifndef NDEBUG
/* For tracing shifts, the names of all terminals and nonterminals
** are required.  The following table supplies these names */
static const char * const yyTokenName[] = {
	"$",             "OPML_XML",      "OPML_WSNL",     "OPML_OPML_OPEN",
	"OPML_OPML_CLOSE",  "OPML_HEAD_OPEN",  "OPML_HEAD_CLOSE",  "OPML_TITLE_OPEN",
	"OPML_TITLE_CLOSE",  "OPML_BODY_OPEN",  "OPML_BODY_CLOSE",  "OPML_OUTLINE_OPEN",
	"OPML_OUTLINE_CLOSE",  "OPML_OUTLINE_PREAMBLE",  "OPML_OUTLINE_METADATA",  "OPML_OUTLINE_SELF_CLOSE",
	"error",         "doc",           "doc_xml",       "doc_opml",
	"opml_header",   "opml_body",     "opml_title",    "opml_outlines",
	"opml_outline",
};
#endif /* NDEBUG */

#ifndef NDEBUG
/* For tracing reduce actions, the names of all rules are required.
*/
static const char * const yyRuleName[] = {
	/*   0 */ "doc ::= doc_xml",
	/*   1 */ "doc_xml ::= OPML_XML doc_opml",
	/*   2 */ "doc_xml ::= doc_opml",
	/*   3 */ "doc_xml ::= OPML_XML doc_opml OPML_WSNL",
	/*   4 */ "doc_xml ::= doc_opml OPML_WSNL",
	/*   5 */ "doc_opml ::= OPML_OPML_OPEN opml_header opml_body OPML_OPML_CLOSE",
	/*   6 */ "doc_opml ::= OPML_OPML_OPEN opml_body OPML_OPML_CLOSE",
	/*   7 */ "opml_header ::= OPML_HEAD_OPEN opml_title OPML_HEAD_CLOSE",
	/*   8 */ "opml_header ::= OPML_HEAD_OPEN OPML_HEAD_CLOSE",
	/*   9 */ "opml_title ::= OPML_TITLE_OPEN OPML_TITLE_CLOSE",
	/*  10 */ "opml_body ::= OPML_BODY_OPEN opml_outlines OPML_BODY_CLOSE",
	/*  11 */ "opml_body ::= OPML_BODY_OPEN OPML_BODY_CLOSE",
	/*  12 */ "opml_outlines ::= opml_outlines opml_outline",
	/*  13 */ "opml_outlines ::= opml_outline",
	/*  14 */ "opml_outline ::= OPML_OUTLINE_OPEN OPML_OUTLINE_CLOSE",
	/*  15 */ "opml_outline ::= OPML_OUTLINE_PREAMBLE OPML_OUTLINE_CLOSE",
	/*  16 */ "opml_outline ::= OPML_OUTLINE_OPEN opml_outlines OPML_OUTLINE_CLOSE",
	/*  17 */ "opml_outline ::= OPML_OUTLINE_METADATA opml_outlines OPML_OUTLINE_CLOSE",
	/*  18 */ "opml_outline ::= OPML_OUTLINE_SELF_CLOSE",
};
#endif /* NDEBUG */


#if YYSTACKDEPTH<=0
/*
** Try to increase the size of the parser stack.  Return the number
** of errors.  Return 0 on success.
*/
static int yyGrowStack(yyParser * p) {
	int newSize;
	int idx;
	yyStackEntry * pNew;

	newSize = p->yystksz * 2 + 100;
	idx = p->yytos ? (int)(p->yytos - p->yystack) : 0;

	if ( p->yystack == &p->yystk0 ) {
		pNew = malloc(newSize * sizeof(pNew[0]));

		if ( pNew ) {
			pNew[0] = p->yystk0;
		}
	} else {
		pNew = realloc(p->yystack, newSize * sizeof(pNew[0]));
	}

	if ( pNew ) {
		p->yystack = pNew;
		p->yytos = &p->yystack[idx];
#ifndef NDEBUG

		if ( yyTraceFILE ) {
			fprintf(yyTraceFILE, "%sStack grows from %d to %d entries.\n",
					yyTracePrompt, p->yystksz, newSize);
		}

#endif
		p->yystksz = newSize;
	}

	return pNew == 0;
}
#endif

/* Datatype of the argument to the memory allocated passed as the
** second argument to OPMLAlloc() below.  This can be changed by
** putting an appropriate #define in the %include section of the input
** grammar.
*/
#ifndef YYMALLOCARGTYPE
	#define YYMALLOCARGTYPE size_t
#endif

/*
** This function allocates a new parser.
** The only argument is a pointer to a function which works like
** malloc.
**
** Inputs:
** A pointer to the function used to allocate memory.
**
** Outputs:
** A pointer to a parser.  This pointer is used in subsequent calls
** to OPML and OPMLFree.
*/
void * OPMLAlloc(void * (*mallocProc)(YYMALLOCARGTYPE)) {
	yyParser * pParser;
	pParser = (yyParser *)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );

	if ( pParser ) {
#ifdef YYTRACKMAXSTACKDEPTH
		pParser->yyhwm = 0;
#endif
#if YYSTACKDEPTH<=0
		pParser->yytos = NULL;
		pParser->yystack = NULL;
		pParser->yystksz = 0;

		if ( yyGrowStack(pParser) ) {
			pParser->yystack = &pParser->yystk0;
			pParser->yystksz = 1;
		}

#endif
#ifndef YYNOERRORRECOVERY
		pParser->yyerrcnt = -1;
#endif
		pParser->yytos = pParser->yystack;
		pParser->yystack[0].stateno = 0;
		pParser->yystack[0].major = 0;
	}

	return pParser;
}

/* The following function deletes the "minor type" or semantic value
** associated with a symbol.  The symbol can be either a terminal
** or nonterminal. "yymajor" is the symbol code, and "yypminor" is
** a pointer to the value to be deleted.  The code used to do the
** deletions is derived from the %destructor and/or %token_destructor
** directives of the input grammar.
*/
static void yy_destructor(
	yyParser * yypParser,   /* The parser */
	YYCODETYPE yymajor,     /* Type code for object to destroy */
	YYMINORTYPE * yypminor  /* The object to be destroyed */
) {
	OPMLARG_FETCH;

	switch ( yymajor ) {
		/* Here is inserted the actions which take place when a
		** terminal or non-terminal is destroyed.  This can happen
		** when the symbol is popped from the stack during a
		** reduce or during error processing or when a parser is
		** being destroyed before it is finished parsing.
		**
		** Note: during a reduce, the only symbols destroyed are those
		** which appear on the RHS of the rule, but which are *not* used
		** inside the C code.
		*/
		/********* Begin destructor definitions ***************************************/
		/********* End destructor definitions *****************************************/
		default:
			break;   /* If no destructor action specified: do nothing */
	}
}

/*
** Pop the parser's stack once.
**
** If there is a destructor routine associated with the token which
** is popped from the stack, then call it.
*/
static void yy_pop_parser_stack(yyParser * pParser) {
	yyStackEntry * yytos;
	assert( pParser->yytos != 0 );
	assert( pParser->yytos > pParser->yystack );
	yytos = pParser->yytos--;
#ifndef NDEBUG

	if ( yyTraceFILE ) {
		fprintf(yyTraceFILE, "%sPopping %s\n",
				yyTracePrompt,
				yyTokenName[yytos->major]);
	}

#endif
	yy_destructor(pParser, yytos->major, &yytos->minor);
}

/*
** Deallocate and destroy a parser.  Destructors are called for
** all stack elements before shutting the parser down.
**
** If the YYPARSEFREENEVERNULL macro exists (for example because it
** is defined in a %include section of the input grammar) then it is
** assumed that the input pointer is never NULL.
*/
void OPMLFree(
	void * p,                   /* The parser to be deleted */
	void (*freeProc)(void *)    /* Function used to reclaim memory */
) {
	yyParser * pParser = (yyParser *)p;
#ifndef YYPARSEFREENEVERNULL

	if ( pParser == 0 ) {
		return;
	}

#endif

	while ( pParser->yytos > pParser->yystack ) {
		yy_pop_parser_stack(pParser);
	}

#if YYSTACKDEPTH<=0

	if ( pParser->yystack != &pParser->yystk0 ) {
		free(pParser->yystack);
	}

#endif
	(*freeProc)((void *)pParser);
}

/*
** Return the peak depth of the stack for a parser.
*/
#ifdef YYTRACKMAXSTACKDEPTH
int OPMLStackPeak(void * p) {
	yyParser * pParser = (yyParser *)p;
	return pParser->yyhwm;
}
#endif

/*
** Find the appropriate action for a parser given the terminal
** look-ahead token iLookAhead.
*/
static unsigned int yy_find_shift_action(
	yyParser * pParser,       /* The parser */
	YYCODETYPE iLookAhead     /* The look-ahead token */
) {
	int i;
	int stateno = pParser->yytos->stateno;

	if ( stateno >= YY_MIN_REDUCE ) {
		return stateno;
	}

	assert( stateno <= YY_SHIFT_COUNT );

	do {
		i = yy_shift_ofst[stateno];
		assert( iLookAhead != YYNOCODE );
		i += iLookAhead;

		if ( i < 0 || i >= YY_ACTTAB_COUNT || yy_lookahead[i] != iLookAhead ) {
#ifdef YYFALLBACK
			YYCODETYPE iFallback;            /* Fallback token */

			if ( iLookAhead < sizeof(yyFallback) / sizeof(yyFallback[0])
					&& (iFallback = yyFallback[iLookAhead]) != 0 ) {
#ifndef NDEBUG

				if ( yyTraceFILE ) {
					fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
							yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
				}

#endif
				assert( yyFallback[iFallback] == 0 ); /* Fallback loop must terminate */
				iLookAhead = iFallback;
				continue;
			}

#endif
#ifdef YYWILDCARD
			{
				int j = i - iLookAhead + YYWILDCARD;

				if (
#if YY_SHIFT_MIN+YYWILDCARD<0
					j >= 0 &&
#endif
#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
					j < YY_ACTTAB_COUNT &&
#endif
					yy_lookahead[j] == YYWILDCARD && iLookAhead > 0
				) {
#ifndef NDEBUG

					if ( yyTraceFILE ) {
						fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
								yyTracePrompt, yyTokenName[iLookAhead],
								yyTokenName[YYWILDCARD]);
					}

#endif /* NDEBUG */
					return yy_action[j];
				}
			}
#endif /* YYWILDCARD */
			return yy_default[stateno];
		} else {
			return yy_action[i];
		}
	} while (1);
}

/*
** Find the appropriate action for a parser given the non-terminal
** look-ahead token iLookAhead.
*/
static int yy_find_reduce_action(
	int stateno,              /* Current state number */
	YYCODETYPE iLookAhead     /* The look-ahead token */
) {
	int i;
#ifdef YYERRORSYMBOL

	if ( stateno > YY_REDUCE_COUNT ) {
		return yy_default[stateno];
	}

#else
	assert( stateno <= YY_REDUCE_COUNT );
#endif
	i = yy_reduce_ofst[stateno];
	assert( i != YY_REDUCE_USE_DFLT );
	assert( iLookAhead != YYNOCODE );
	i += iLookAhead;
#ifdef YYERRORSYMBOL

	if ( i < 0 || i >= YY_ACTTAB_COUNT || yy_lookahead[i] != iLookAhead ) {
		return yy_default[stateno];
	}

#else
	assert( i >= 0 && i < YY_ACTTAB_COUNT );
	assert( yy_lookahead[i] == iLookAhead );
#endif
	return yy_action[i];
}

/*
** The following routine is called if the stack overflows.
*/
static void yyStackOverflow(yyParser * yypParser) {
	OPMLARG_FETCH;
	yypParser->yytos--;
#ifndef NDEBUG

	if ( yyTraceFILE ) {
		fprintf(yyTraceFILE, "%sStack Overflow!\n", yyTracePrompt);
	}

#endif

	while ( yypParser->yytos > yypParser->yystack ) {
		yy_pop_parser_stack(yypParser);
	}

	/* Here code is inserted which will execute if the parser
	** stack every overflows */
	/******** Begin %stack_overflow code ******************************************/
	/******** End %stack_overflow code ********************************************/
	OPMLARG_STORE; /* Suppress warning about unused %extra_argument var */
}

/*
** Print tracing information for a SHIFT action
*/
#ifndef NDEBUG
static void yyTraceShift(yyParser * yypParser, int yyNewState) {
	if ( yyTraceFILE ) {
		if ( yyNewState < YYNSTATE ) {
			fprintf(yyTraceFILE, "%sShift '%s', go to state %d\n",
					yyTracePrompt, yyTokenName[yypParser->yytos->major],
					yyNewState);
		} else {
			fprintf(yyTraceFILE, "%sShift '%s'\n",
					yyTracePrompt, yyTokenName[yypParser->yytos->major]);
		}
	}
}
#else
# define yyTraceShift(X,Y)
#endif

/*
** Perform a shift action.
*/
static void yy_shift(
	yyParser * yypParser,         /* The parser to be shifted */
	int yyNewState,               /* The new state to shift in */
	int yyMajor,                  /* The major token to shift in */
	OPMLTOKENTYPE yyMinor        /* The minor token to shift in */
) {
	yyStackEntry * yytos;
	yypParser->yytos++;
#ifdef YYTRACKMAXSTACKDEPTH

	if ( (int)(yypParser->yytos - yypParser->yystack) > yypParser->yyhwm ) {
		yypParser->yyhwm++;
		assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
	}

#endif
#if YYSTACKDEPTH>0

	if ( yypParser->yytos >= &yypParser->yystack[YYSTACKDEPTH] ) {
		yyStackOverflow(yypParser);
		return;
	}

#else

	if ( yypParser->yytos >= &yypParser->yystack[yypParser->yystksz] ) {
		if ( yyGrowStack(yypParser) ) {
			yyStackOverflow(yypParser);
			return;
		}
	}

#endif

	if ( yyNewState > YY_MAX_SHIFT ) {
		yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
	}

	yytos = yypParser->yytos;
	yytos->stateno = (YYACTIONTYPE)yyNewState;
	yytos->major = (YYCODETYPE)yyMajor;
	yytos->minor.yy0 = yyMinor;
	yyTraceShift(yypParser, yyNewState);
}

/* The following table contains information about every rule that
** is used during the reduce.
*/
static const struct {
	YYCODETYPE lhs;         /* Symbol on the left-hand side of the rule */
	unsigned char nrhs;     /* Number of right-hand side symbols in the rule */
} yyRuleInfo[] = {
	{ 17, 1 },
	{ 18, 2 },
	{ 18, 1 },
	{ 18, 3 },
	{ 18, 2 },
	{ 19, 4 },
	{ 19, 3 },
	{ 20, 3 },
	{ 20, 2 },
	{ 22, 2 },
	{ 21, 3 },
	{ 21, 2 },
	{ 23, 2 },
	{ 23, 1 },
	{ 24, 2 },
	{ 24, 2 },
	{ 24, 3 },
	{ 24, 3 },
	{ 24, 1 },
};

static void yy_accept(yyParser *); /* Forward Declaration */

/*
** Perform a reduce action and the shift that must immediately
** follow the reduce.
*/
static void yy_reduce(
	yyParser * yypParser,        /* The parser */
	unsigned int yyruleno        /* Number of the rule by which to reduce */
) {
	int yygoto;                     /* The next state */
	int yyact;                      /* The next action */
	yyStackEntry * yymsp;           /* The top of the parser's stack */
	int yysize;                     /* Amount to pop the stack */
	OPMLARG_FETCH;
	yymsp = yypParser->yytos;
#ifndef NDEBUG

	if ( yyTraceFILE && yyruleno < (int)(sizeof(yyRuleName) / sizeof(yyRuleName[0])) ) {
		yysize = yyRuleInfo[yyruleno].nrhs;
		fprintf(yyTraceFILE, "%sReduce [%s], go to state %d.\n", yyTracePrompt,
				yyRuleName[yyruleno], yymsp[-yysize].stateno);
	}

#endif /* NDEBUG */

	/* Check that the stack is large enough to grow by a single entry
	** if the RHS of the rule is empty.  This ensures that there is room
	** enough on the stack to push the LHS value */
	if ( yyRuleInfo[yyruleno].nrhs == 0 ) {
#ifdef YYTRACKMAXSTACKDEPTH

		if ( (int)(yypParser->yytos - yypParser->yystack) > yypParser->yyhwm ) {
			yypParser->yyhwm++;
			assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
		}

#endif
#if YYSTACKDEPTH>0

		if ( yypParser->yytos >= &yypParser->yystack[YYSTACKDEPTH - 1] ) {
			yyStackOverflow(yypParser);
			return;
		}

#else

		if ( yypParser->yytos >= &yypParser->yystack[yypParser->yystksz - 1] ) {
			if ( yyGrowStack(yypParser) ) {
				yyStackOverflow(yypParser);
				return;
			}

			yymsp = yypParser->yytos;
		}

#endif
	}

	switch ( yyruleno ) {
		/* Beginning here are the reduction cases.  A typical example
		** follows:
		**   case 0:
		**  #line <lineno> <grammarfile>
		**     { ... }           // User supplied code
		**  #line <lineno> <thisfile>
		**     break;
		*/
		/********** Begin reduce actions **********************************************/
		case 0: { /* doc ::= doc_xml */
			engine->root = yymsp[0].minor.yy0;
		}
		break;

		default:
			/* (1) doc_xml ::= OPML_XML doc_opml */
			yytestcase(yyruleno == 1);
			/* (2) doc_xml ::= doc_opml */ yytestcase(yyruleno == 2);
			/* (3) doc_xml ::= OPML_XML doc_opml OPML_WSNL */ yytestcase(yyruleno == 3);
			/* (4) doc_xml ::= doc_opml OPML_WSNL */ yytestcase(yyruleno == 4);
			/* (5) doc_opml ::= OPML_OPML_OPEN opml_header opml_body OPML_OPML_CLOSE */ yytestcase(yyruleno == 5);
			/* (6) doc_opml ::= OPML_OPML_OPEN opml_body OPML_OPML_CLOSE */ yytestcase(yyruleno == 6);
			/* (7) opml_header ::= OPML_HEAD_OPEN opml_title OPML_HEAD_CLOSE */ yytestcase(yyruleno == 7);
			/* (8) opml_header ::= OPML_HEAD_OPEN OPML_HEAD_CLOSE */ yytestcase(yyruleno == 8);
			/* (9) opml_title ::= OPML_TITLE_OPEN OPML_TITLE_CLOSE */ yytestcase(yyruleno == 9);
			/* (10) opml_body ::= OPML_BODY_OPEN opml_outlines OPML_BODY_CLOSE */ yytestcase(yyruleno == 10);
			/* (11) opml_body ::= OPML_BODY_OPEN OPML_BODY_CLOSE */ yytestcase(yyruleno == 11);
			/* (12) opml_outlines ::= opml_outlines opml_outline */ yytestcase(yyruleno == 12);
			/* (13) opml_outlines ::= opml_outline (OPTIMIZED OUT) */ assert(yyruleno != 13);
			/* (14) opml_outline ::= OPML_OUTLINE_OPEN OPML_OUTLINE_CLOSE */ yytestcase(yyruleno == 14);
			/* (15) opml_outline ::= OPML_OUTLINE_PREAMBLE OPML_OUTLINE_CLOSE */ yytestcase(yyruleno == 15);
			/* (16) opml_outline ::= OPML_OUTLINE_OPEN opml_outlines OPML_OUTLINE_CLOSE */ yytestcase(yyruleno == 16);
			/* (17) opml_outline ::= OPML_OUTLINE_METADATA opml_outlines OPML_OUTLINE_CLOSE */ yytestcase(yyruleno == 17);
			/* (18) opml_outline ::= OPML_OUTLINE_SELF_CLOSE */ yytestcase(yyruleno == 18);
			break;
			/********** End reduce actions ************************************************/
	};

	assert( yyruleno < sizeof(yyRuleInfo) / sizeof(yyRuleInfo[0]) );

	yygoto = yyRuleInfo[yyruleno].lhs;

	yysize = yyRuleInfo[yyruleno].nrhs;

	yyact = yy_find_reduce_action(yymsp[-yysize].stateno, (YYCODETYPE)yygoto);

	if ( yyact <= YY_MAX_SHIFTREDUCE ) {
		if ( yyact > YY_MAX_SHIFT ) {
			yyact += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
		}

		yymsp -= yysize - 1;
		yypParser->yytos = yymsp;
		yymsp->stateno = (YYACTIONTYPE)yyact;
		yymsp->major = (YYCODETYPE)yygoto;
		yyTraceShift(yypParser, yyact);
	} else {
		assert( yyact == YY_ACCEPT_ACTION );
		yypParser->yytos -= yysize;
		yy_accept(yypParser);
	}
}

/*
** The following code executes when the parse fails
*/
#ifndef YYNOERRORRECOVERY
static void yy_parse_failed(
	yyParser * yypParser          /* The parser */
) {
	OPMLARG_FETCH;
#ifndef NDEBUG

	if ( yyTraceFILE ) {
		fprintf(yyTraceFILE, "%sFail!\n", yyTracePrompt);
	}

#endif

	while ( yypParser->yytos > yypParser->yystack ) {
		yy_pop_parser_stack(yypParser);
	}

	/* Here code is inserted which will be executed whenever the
	** parser fails */
	/************ Begin %parse_failure code ***************************************/

	fprintf(stderr, "Parser failed to successfully parse.\n");
	/************ End %parse_failure code *****************************************/
	OPMLARG_STORE; /* Suppress warning about unused %extra_argument variable */
}
#endif /* YYNOERRORRECOVERY */

/*
** The following code executes when a syntax error first occurs.
*/
static void yy_syntax_error(
	yyParser * yypParser,          /* The parser */
	int yymajor,                   /* The major type of the error token */
	OPMLTOKENTYPE yyminor         /* The minor type of the error token */
) {
	OPMLARG_FETCH;
#define TOKEN yyminor
	/************ Begin %syntax_error code ****************************************/

	fprintf(stderr, "Parser syntax error.\n");
#ifndef NDEBUG
	fprintf(stderr, "Parser syntax error.\n");
	int n = sizeof(yyTokenName) / sizeof(yyTokenName[0]);

	for (int i = 0; i < n; ++i) {
		int a = yy_find_shift_action(yypParser, (YYCODETYPE)i);

		if (a < YYNSTATE + YYNRULE) {
			fprintf(stderr, "expected token: %s\n", yyTokenName[i]);
		}
	}

#endif
	/************ End %syntax_error code ******************************************/
	OPMLARG_STORE; /* Suppress warning about unused %extra_argument variable */
}

/*
** The following is executed when the parser accepts
*/
static void yy_accept(
	yyParser * yypParser          /* The parser */
) {
	OPMLARG_FETCH;
#ifndef NDEBUG

	if ( yyTraceFILE ) {
		fprintf(yyTraceFILE, "%sAccept!\n", yyTracePrompt);
	}

#endif
#ifndef YYNOERRORRECOVERY
	yypParser->yyerrcnt = -1;
#endif
	assert( yypParser->yytos == yypParser->yystack );
	/* Here code is inserted which will be executed whenever the
	** parser accepts */
	/*********** Begin %parse_accept code *****************************************/

//	printf("parsing completed successfully!\n");
	/*********** End %parse_accept code *******************************************/
	OPMLARG_STORE; /* Suppress warning about unused %extra_argument variable */
}

/* The main parser program.
** The first argument is a pointer to a structure obtained from
** "OPMLAlloc" which describes the current state of the parser.
** The second argument is the major token number.  The third is
** the minor token.  The fourth optional argument is whatever the
** user wants (and specified in the grammar) and is available for
** use by the action routines.
**
** Inputs:
** <ul>
** <li> A pointer to the parser (an opaque structure.)
** <li> The major token number.
** <li> The minor token number.
** <li> An option argument of a grammar-specified type.
** </ul>
**
** Outputs:
** None.
*/
void OPML(
	void * yyp,                  /* The parser */
	int yymajor,                 /* The major token code number */
	OPMLTOKENTYPE yyminor       /* The value for the token */
	OPMLARG_PDECL               /* Optional %extra_argument parameter */
) {
	YYMINORTYPE yyminorunion;
	unsigned int yyact;   /* The parser action. */
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
	int yyendofinput;     /* True if we are at the end of input */
#endif
#ifdef YYERRORSYMBOL
	int yyerrorhit = 0;   /* True if yymajor has invoked an error */
#endif
	yyParser * yypParser; /* The parser */

	yypParser = (yyParser *)yyp;
	assert( yypParser->yytos != 0 );
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
	yyendofinput = (yymajor == 0);
#endif
	OPMLARG_STORE;

#ifndef NDEBUG

	if ( yyTraceFILE ) {
		fprintf(yyTraceFILE, "%sInput '%s'\n", yyTracePrompt, yyTokenName[yymajor]);
	}

#endif

	do {
		yyact = yy_find_shift_action(yypParser, (YYCODETYPE)yymajor);

		if ( yyact <= YY_MAX_SHIFTREDUCE ) {
			yy_shift(yypParser, yyact, yymajor, yyminor);
#ifndef YYNOERRORRECOVERY
			yypParser->yyerrcnt--;
#endif
			yymajor = YYNOCODE;
		} else if ( yyact <= YY_MAX_REDUCE ) {
			yy_reduce(yypParser, yyact - YY_MIN_REDUCE);
		} else {
			assert( yyact == YY_ERROR_ACTION );
			yyminorunion.yy0 = yyminor;
#ifdef YYERRORSYMBOL
			int yymx;
#endif
#ifndef NDEBUG

			if ( yyTraceFILE ) {
				fprintf(yyTraceFILE, "%sSyntax Error!\n", yyTracePrompt);
			}

#endif
#ifdef YYERRORSYMBOL

			/* A syntax error has occurred.
			** The response to an error depends upon whether or not the
			** grammar defines an error token "ERROR".
			**
			** This is what we do if the grammar does define ERROR:
			**
			**  * Call the %syntax_error function.
			**
			**  * Begin popping the stack until we enter a state where
			**    it is legal to shift the error symbol, then shift
			**    the error symbol.
			**
			**  * Set the error count to three.
			**
			**  * Begin accepting and shifting new tokens.  No new error
			**    processing will occur until three tokens have been
			**    shifted successfully.
			**
			*/
			if ( yypParser->yyerrcnt < 0 ) {
				yy_syntax_error(yypParser, yymajor, yyminor);
			}

			yymx = yypParser->yytos->major;

			if ( yymx == YYERRORSYMBOL || yyerrorhit ) {
#ifndef NDEBUG

				if ( yyTraceFILE ) {
					fprintf(yyTraceFILE, "%sDiscard input token %s\n",
							yyTracePrompt, yyTokenName[yymajor]);
				}

#endif
				yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
				yymajor = YYNOCODE;
			} else {
				while ( yypParser->yytos >= yypParser->yystack
						&& yymx != YYERRORSYMBOL
						&& (yyact = yy_find_reduce_action(
										yypParser->yytos->stateno,
										YYERRORSYMBOL)) >= YY_MIN_REDUCE
					  ) {
					yy_pop_parser_stack(yypParser);
				}

				if ( yypParser->yytos < yypParser->yystack || yymajor == 0 ) {
					yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
					yy_parse_failed(yypParser);
#ifndef YYNOERRORRECOVERY
					yypParser->yyerrcnt = -1;
#endif
					yymajor = YYNOCODE;
				} else if ( yymx != YYERRORSYMBOL ) {
					yy_shift(yypParser, yyact, YYERRORSYMBOL, yyminor);
				}
			}

			yypParser->yyerrcnt = 3;
			yyerrorhit = 1;
#elif defined(YYNOERRORRECOVERY)
			/* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
			** do any kind of error recovery.  Instead, simply invoke the syntax
			** error routine and continue going as if nothing had happened.
			**
			** Applications can set this macro (for example inside %include) if
			** they intend to abandon the parse upon the first syntax error seen.
			*/
			yy_syntax_error(yypParser, yymajor, yyminor);
			yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
			yymajor = YYNOCODE;

#else  /* YYERRORSYMBOL is not defined */

			/* This is what we do if the grammar does not define ERROR:
			**
			**  * Report an error message, and throw away the input token.
			**
			**  * If the input token is $, then fail the parse.
			**
			** As before, subsequent error messages are suppressed until
			** three input tokens have been successfully shifted.
			*/
			if ( yypParser->yyerrcnt <= 0 ) {
				yy_syntax_error(yypParser, yymajor, yyminor);
			}

			yypParser->yyerrcnt = 3;
			yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);

			if ( yyendofinput ) {
				yy_parse_failed(yypParser);
#ifndef YYNOERRORRECOVERY
				yypParser->yyerrcnt = -1;
#endif
			}

			yymajor = YYNOCODE;
#endif
		}
	} while ( yymajor != YYNOCODE && yypParser->yytos > yypParser->yystack );

#ifndef NDEBUG

	if ( yyTraceFILE ) {
		yyStackEntry * i;
		char cDiv = '[';
		fprintf(yyTraceFILE, "%sReturn. Stack=", yyTracePrompt);

		for (i = &yypParser->yystack[1]; i <= yypParser->yytos; i++) {
			fprintf(yyTraceFILE, "%c%s", cDiv, yyTokenName[i->major]);
			cDiv = ' ';
		}

		fprintf(yyTraceFILE, "]\n");
	}

#endif
	return;
}
